Protoshow sprint.

[rbdr/super-polarity] / Super Polarity / InputController.cs

diff --git a/Super Polarity/InputController.cs b/Super Polarity/InputController.cs
index 405b3abde5fbc3625c359ce835c1ea50071d068d..c92bb9c37b8bc7500d8762d35d3c2fcf068428f3 100644 (file)
--- a/Super Polarity/InputController.cs
+++ b/Super Polarity/InputController.cs
@@ -11,6 +11,8 @@ namespace SuperPolarity
         static Dictionary<string, List<Action<float>>> Listeners;
         static Dictionary<string, List<Keys>> RegisteredKeys;
         static Dictionary<string, List<Buttons>> RegisteredButtons;
+        static List<string> BlockedKeys;
+        static List<string> BlockedButtons;
 
         static GamePadState InputGamePadState;
         static KeyboardState InputKeyboardState;
@@ -25,25 +27,134 @@ namespace SuperPolarity
         static InputController()
         {
             Listeners = new Dictionary<string,List<Action<float>>>();
+            RegisteredButtons = new Dictionary<string, List<Buttons>>();
+            RegisteredKeys = new Dictionary<string, List<Keys>>();
+            BlockedKeys = new List<string>();
+            BlockedButtons = new List<string>();
             InputKeyboardState = new KeyboardState();
             InputGamePadState = new GamePadState();
         }
 
         public static void UpdateInput()
         {
-            Poll();
             DispatchMoveEvents();
             DispatchRegisteredEvents();
         }
 
+        public static void UpdateInput(bool highPriorityOnly) 
+        {
+            Poll();
+            DispatchPauseEvent();
+            if (!highPriorityOnly)
+            {
+                UpdateInput();
+            }
+        }
+
+        public static void DispatchPauseEvent()
+        {
+            // OK THIS IS ALL KINDS OF WRONG. THIS IS A PLACEHOLDER BECAUSE DEMO!
+            var keyPressed = false;
+            if ((InputKeyboardState.IsKeyDown(Keys.Enter) || InputGamePadState.IsButtonDown(Buttons.Start))) {
+                keyPressed = true;
+                if(!BlockedButtons.Contains("pause") && !BlockedKeys.Contains("pause"))
+                {
+                    BlockedButtons.Add("pause");
+                    BlockedKeys.Add("pause");
+                    Console.WriteLine("Dispatch");
+                    Dispatch("pause", 0);
+                }
+            }
+
+            if (!keyPressed)
+            {
+                BlockedButtons.Remove("pause");
+                BlockedKeys.Remove("pause");
+            }
+        }
+
         private static void Poll()
         {
             InputGamePadState = GamePad.GetState(Microsoft.Xna.Framework.PlayerIndex.One);
             InputKeyboardState = Keyboard.GetState();
         }
 
+        public static void RegisterEventForKey(string eventName, Keys key)
+        {
+            List<Keys> newKeyList;
+            if (!RegisteredKeys.ContainsKey(eventName))
+            {
+                newKeyList = new List<Keys>();
+                RegisteredKeys.Add(eventName, newKeyList);
+            }
+
+            RegisteredKeys.TryGetValue(eventName, out newKeyList);
+
+            newKeyList.Add(key);
+        }
+
+        public static void RegisterEventForButton(string eventName, Buttons button)
+        {
+            List<Buttons> newButtonList;
+            if (!RegisteredButtons.ContainsKey(eventName))
+            {
+                newButtonList = new List<Buttons>();
+                RegisteredButtons.Add(eventName, newButtonList);
+            }
+
+            RegisteredButtons.TryGetValue(eventName, out newButtonList);
+
+            newButtonList.Add(button);
+        }
+
         private static void DispatchRegisteredEvents()
         {
+            var keyFired = false;
+
+            foreach (KeyValuePair<string,List<Keys>> entry in RegisteredKeys) {
+                keyFired = false;
+                foreach (Keys key in entry.Value)
+                {
+                    if (InputKeyboardState.IsKeyDown(key))
+                    {
+                        if (!BlockedKeys.Contains(entry.Key))
+                        {
+                            BlockedKeys.Add(entry.Key);
+                            Dispatch(entry.Key, 1);
+                        }
+                        keyFired = true;
+                        break;
+                    }
+                }
+
+                if (!keyFired)
+                {
+                    BlockedKeys.Remove(entry.Key);
+                }
+            }
+
+            foreach (KeyValuePair<string, List<Buttons>> entry in RegisteredButtons)
+            {
+                keyFired = false;
+                foreach (Buttons button in entry.Value)
+                {
+                    if (InputGamePadState.IsButtonDown(button))
+                    {
+                        if (!BlockedButtons.Contains(entry.Key))
+                        {
+                            BlockedButtons.Add(entry.Key);
+                            Dispatch(entry.Key, 1);
+                        }
+                        keyFired = true;
+                        break;
+                    };
+                }
+
+                if (!keyFired)
+                {
+                    BlockedButtons.Remove(entry.Key);
+                }
+            }
         }
 
         private static void DispatchMoveEvents()
@@ -55,8 +166,6 @@ namespace SuperPolarity
             xMovement = InputGamePadState.ThumbSticks.Left.X;
             yMovement = -InputGamePadState.ThumbSticks.Left.Y;
 
-            Console.WriteLine("Dispatching Input {0}", InputKeyboardState.IsKeyDown(Keys.Left));
-
             if (InputKeyboardState.IsKeyDown(Keys.Left))
             {
                 xMovement = -1.0f;
@@ -97,6 +206,21 @@ namespace SuperPolarity
             listenerList.Add(listener);
         }
 
+        public static void Unbind(string eventName, Action<float> listener)
+        {
+            List<Action<float>> listenerList;
+            bool foundListeners;
+
+            if (!Listeners.ContainsKey(eventName))
+            {
+                return;
+            }
+
+            foundListeners = Listeners.TryGetValue(eventName, out listenerList);
+
+            listenerList.Remove(listener);
+        }
+
         public static void Dispatch(string eventName, float value)
         {
             List<Action<float>> listenerList;
@@ -109,10 +233,16 @@ namespace SuperPolarity
                 return;
             }
 
-            foreach (Action<float> method in listenerList)
+            for (var i = listenerList.Count - 1; i >= 0; i--)
             {
-                method(value);
+                listenerList[i](value);
             }
         }
+
+        public static void Unlock(string eventName)
+        {
+            BlockedButtons.Remove(eventName);
+            BlockedKeys.Remove(eventName);
+        }
     }
 }